package Logica;
import java.util.ArrayList;
    


public class Nodo {
    
    int operacionAplicada[];  
    /*Operacion aplicada contiene el indice de la ficha movida , el desplazamiento en x y el desplazamiento en y*/
    Nodo padre;
    int profundidad;
    String tipo;
    int posiciones[][]=new int[16][2];
    int color;
    String[]fichas={"p","P","p","P","p","P","p","P","b","B","h","H","q","Q","k","K"};
    int pesos[]={1,-1,1,-1,1,-1,1,-1,3,-3,3,-3,9,-9,30,-30};
    String tablero[][]=new String [6][6];
    int incrementos[][]=new int[8][2];
    int incrementosCaballo[][]=new int[8][2];
    double heuristica=0;
    boolean enJaque=false;
   

    public Nodo(int posiciones[][], int[] operacionAplicada, Nodo padre,int color,int profundidad) {       
        this.posiciones=posiciones;
        this.operacionAplicada = operacionAplicada;
        this.padre = padre;
        this.color=color;
        this.profundidad=profundidad;    
        GenerarTablero(posiciones);
        
        incrementos[0][1]=incrementos[1][1]=incrementos[1][0]=incrementos[7][1]=incrementos[2][0]=incrementos[3][0]=-1;
        incrementos[0][0]=incrementos[2][1]=incrementos[4][0]=incrementos[6][1]=0;
        incrementos[3][1]=incrementos[4][1]=incrementos[5][1]=incrementos[5][0]=incrementos[6][0]=incrementos[7][0]=1;
        
        
        incrementosCaballo[0][0]=incrementosCaballo[1][0]=incrementosCaballo[7][1]=incrementosCaballo[6][1]=-2;
         incrementosCaballo[7][0]=incrementosCaballo[2][0]=incrementosCaballo[0][1]=incrementosCaballo[5][1]=-1;
         incrementosCaballo[6][0]=incrementosCaballo[3][0]=incrementosCaballo[1][1]=incrementosCaballo[4][1]=1;
         incrementosCaballo[5][0]=incrementosCaballo[4][0]=incrementosCaballo[2][1]=incrementosCaballo[3][1]=2;
    
    }
     public String[][] GenerarTablero(int posiciones[][])
   {
       int posicion[];
       for (int i = 0; i < 6; i++) {
           for (int j = 0; j < 6; j++) {
               tablero[i][j]="0";               
           }           
       }
       for (int i = 0; i < 16; i++) {
           posicion=posiciones[i];
           if(posicion[0]>=0)
           {
              tablero[posicion[0]][posicion[1]]=fichas[i]; 
           }
       }
       return tablero;       
   }
     
     public String[][] getTablero(){
       return tablero;
   }
    
 
    public double CalcularHeuristica()
   {
       int pesoBlanco=0,pesoNegro=0,factorProtBlanco=0,factorProtNegro=0,factorAtaqueBlanco=1,factorAtaqueNegro=1;
       for(int i=0;i<16;i++)
       {
           if(posiciones[i][0]!=-1)
           {
              if(i%2==0)pesoBlanco+=pesos[i];
              else pesoNegro+=pesos[i];
           }
       }

//       int rey[],reyContrario[];
//       rey=posiciones[14];
//       reyContrario=posiciones[15];
//       int proxRey[],proxContrario[];
//
//       for(int i=0;i<8;i++)
//       {
//           proxRey=new int[]{rey[0]+incrementos[i][0],rey[1]+incrementos[i][1]};
//           proxContrario=new int[]{reyContrario[0]+incrementos[i][0],reyContrario[1]+incrementos[i][1]};
//           if(!CasillaVacia(proxRey))
//           {
//               if(!FichaContraria(proxRey, 0))factorProtBlanco++;
//           }
//
//           if(!CasillaVacia(proxContrario))
//           {
//               if(!FichaContraria(proxContrario, 1))factorProtNegro++;
//           }
//       }
////       
//             for(int i=0;i<16;i++){
//
//                     if(i%2==0){factorAtaqueBlanco+=Contiene(GenerarPosiblesMovimientos(posiciones[i]),posiciones[15]);}
//                      if(i%2==1){factorAtaqueNegro+=Contiene(GenerarPosiblesMovimientos(posiciones[i]),posiciones[14]);}
//               }
//
//
//       heuristica= ((factorProtBlanco /factorAtaqueNegro)*pesoBlanco) +((factorProtNegro /factorAtaqueBlanco)*pesoNegro) ;
      heuristica=(pesoBlanco)+(pesoNegro);  
       return heuristica;
   }
    
    public int Contiene(ArrayList<int[]> lista,int pos[]){
    int contiene=0;
       for (int i = 0; i < lista.size(); i++) {
           int object[] = lista.get(i);
           if(object[0]==pos[0]&&object[1]==pos[1])
           {
               contiene=1;
               break;
           }

       }
       return contiene;
   }
   
   public void ImprimirMatriz()
   {
       for (int i = 0; i < 6; i++) {
           for (int j = 0; j < 6; j++) {
               System.out.print(tablero[i][j]+" "); 
           }
           System.out.println();
       }
   }
   
   public void ImprimirMatrizPosiciones()
   {
       for (int i = 0; i < 16; i++) {
           for (int j = 0; j < 2; j++) {
               System.out.print(posiciones[i][j]+" "); 
           }
           System.out.println();
       }
   }
    
   public void VisualizarPosibleJugadas()
   {
      ArrayList<Nodo> movimientos=DeterminarPosiblesJugadas(color);
       for (int i = 0; i < movimientos.size(); i++) {
           Nodo nodo = movimientos.get(i);
           nodo.ImprimirMatriz();
           System.out.println();
           System.out.println();
           nodo.ImprimirMatrizPosiciones();
           
       }
   }
    
     public boolean Jaque(int colorActual)
    {
        boolean jaque=false,evaluacion=false;
        int posicionEvaluar[];
        int rey[]=posiciones[colorActual+14];
        String ficha;
        int incrx=0,incry=0;
         
         while(!(jaque||evaluacion))
         {           
           for (int i = 0; i < 8; i++) {
            posicionEvaluar=new int[]{rey[0]+incrementosCaballo[i][0],rey[1]+incrementosCaballo[i][1]};               
            if(posicionEvaluar[0]>=0&&posicionEvaluar[0]<6&&posicionEvaluar[1]>=0&&posicionEvaluar[1]<6)
                    {
                        if(!CasillaVacia(posicionEvaluar))
                        {
                            if(FichaContraria(posicionEvaluar,colorActual))
                                { 
                                   ficha=fichas[IndiceFicha(posicionEvaluar)];
                                    if(ficha.equalsIgnoreCase("h"))jaque=true;                                    
                                }
                        }
                    }
        }
           
           for (int i = 0; i < 8; i++) {
            posicionEvaluar=new int[]{rey[0]+incrementos[i][0],rey[1]+incrementos[i][1]};
            if(posicionEvaluar[0]>=0&&posicionEvaluar[0]<6&&posicionEvaluar[1]>=0&&posicionEvaluar[1]<6)
            {
                    if(FichaContraria(posicionEvaluar, colorActual))
                    {
                        ficha=fichas[IndiceFicha(posicionEvaluar)];
                        if(ficha.equalsIgnoreCase("k"))jaque=true;
                        else if(ficha.equals("p"))
                        {
                            if(rey[0]-1==posicionEvaluar[0]&&Math.abs(posicionEvaluar[1]-rey[1])==1)jaque=true;
                        }else if(ficha.equals("P"))
                        {
                            if(rey[0]+1==posicionEvaluar[0]&&Math.abs(posicionEvaluar[1]-rey[1])==1)jaque=true;
                        }else if(ficha.equalsIgnoreCase("q"))jaque=true;
                        else if(ficha.equalsIgnoreCase("b"))
                        {
                            if(Math.abs(rey[1]-posicionEvaluar[1])==1)jaque=true;
                        }
                    }
            }
        }
            for (int i = 1; i < 6; i++) {
                for (int j = 0; j < 8; j++) {
                    incrx=i*incrementos[j][0];
                    incry=i*incrementos[j][1];
                    posicionEvaluar=new int[]{rey[0]+incrx,rey[1]+incry};                    
                    if(posicionEvaluar[0]>=0&&posicionEvaluar[0]<6&&posicionEvaluar[1]>=0&&posicionEvaluar[1]<6)
                    {   
                        if(!CasillaVacia(posicionEvaluar))
                        {
                            if(FichaContraria(posicionEvaluar,colorActual))
                                {    
                                    ficha=fichas[IndiceFicha(posicionEvaluar)];
                                    if(ficha.equalsIgnoreCase("b")||ficha.equalsIgnoreCase("q"))
                                    {                                       
                                       if(Math.abs(posicionEvaluar[0]-rey[0])==Math.abs(posicionEvaluar[1]-rey[1]))
                                       {
                                          if(rey[0]>posicionEvaluar[0])
                                          {
                                              if(rey[1]>posicionEvaluar[1])
                                              {
                                                  int cont=1;
                                                   while(posicionEvaluar[1]+cont!=rey[1])
                                                   {
                                                       if(CasillaVacia(new int[]{posicionEvaluar[0]+cont,posicionEvaluar[1]+cont}))cont++;
                                                       else break;
                                                   }
                                                   if(Math.abs(posicionEvaluar[1]-rey[1])==cont)jaque=true;
                                              }
                                              else{
                                                  int cont=1;
                                                   while(posicionEvaluar[1]-cont!=rey[1])
                                                   {
                                                       if(CasillaVacia(new int[]{posicionEvaluar[0]+cont,posicionEvaluar[1]-cont}))cont++;
                                                       else break;
                                                   }
                                                   if(Math.abs(posicionEvaluar[1]-rey[1])==cont)jaque=true;
                                              }
                                          }else{
                                              if(rey[1]>posicionEvaluar[1])
                                              {
                                                  int cont=1;
                                                   while(posicionEvaluar[1]+cont!=rey[1])
                                                   {
                                                       if(CasillaVacia(new int[]{posicionEvaluar[0]-cont,posicionEvaluar[1]+cont}))cont++;
                                                       else break;
                                                   }
                                                   if(Math.abs(posicionEvaluar[1]-rey[1])==cont)jaque=true;
                                              }
                                              else{
                                                  int cont=1;
                                                   while(posicionEvaluar[1]-cont!=rey[1])
                                                   {
                                                       if(CasillaVacia(new int[]{posicionEvaluar[0]-cont,posicionEvaluar[1]-cont}))cont++;
                                                       else break;
                                                   }
                                                   if(Math.abs(posicionEvaluar[1]-rey[1])==cont)jaque=true;
                                              }
                                              
                                          }
                                       }else{
                                           if(ficha.equalsIgnoreCase("q"))
                                           {
                                               if(posicionEvaluar[0]==rey[0])
                                               {
                                                   if(posicionEvaluar[1]<rey[1])
                                                   {
                                                       int cont=1;
                                                       while(posicionEvaluar[1]+cont!=rey[1])
                                                       {
                                                           if(CasillaVacia(new int[]{posicionEvaluar[0],posicionEvaluar[1]+cont}))cont++;
                                                           else break;
                                                       }
                                                       if(Math.abs(posicionEvaluar[1]-rey[1])==cont)jaque=true;
                                                   }
                                                   else{
                                                       int cont=1;
                                                       while(posicionEvaluar[1]-cont!=rey[1])
                                                       {
                                                           if(CasillaVacia(new int[]{posicionEvaluar[0],posicionEvaluar[1]-cont}))cont++;
                                                           else break;
                                                       }
                                                       if(Math.abs(posicionEvaluar[1]-rey[1])==cont)jaque=true;
                                                   }
                                               }
                                               else if(posicionEvaluar[1]==rey[1])
                                               {
                                                   if(posicionEvaluar[0]<rey[0])
                                                   {
                                                       int cont=1;
                                                       while(posicionEvaluar[0]+cont!=rey[0])
                                                       {
                                                           if(CasillaVacia(new int[]{posicionEvaluar[0]+cont,posicionEvaluar[1]}))cont++;
                                                           else break;
                                                       }
                                                       if(Math.abs(posicionEvaluar[0]-rey[0])==cont)jaque=true;
                                                   }
                                                   else{
                                                       int cont=1;
                                                       while(posicionEvaluar[0]-cont!=rey[0])
                                                       {
                                                           if(CasillaVacia(new int[]{posicionEvaluar[0]-cont,posicionEvaluar[1]}))cont++;
                                                           else break;
                                                       }
                                                       if(Math.abs(posicionEvaluar[0]-rey[0])==cont)jaque=true;
                                                   }
                                               }
                                           }
                                       }
                                        
                                    }                         
                                }
                        }
                        
                    }

                }
                
           }
            
          evaluacion=true;  
       }
       enJaque=jaque;
       return jaque;
    }
    
    public boolean MasMovimientos(int color)
    {
        int nJugadas=DeterminarPosiblesJugadas(color).size();
        if(nJugadas==0)return false;
        else return true;
    }
     public boolean InsuficienciaMaterial()
     {
         boolean insuficiencia=true,evaluacion=false;
         ArrayList indices=new ArrayList();
         int cont=0;
         while(!(insuficiencia||evaluacion))
         {
              for (int i = 0; i < 16; i++) {
                 if(posiciones[i][0]!=1){
                     if(fichas[i].equalsIgnoreCase("q"))evaluacion=true;
                     else{
                         indices.add(fichas[i]);
                         cont++;
                     }
                 }
             }
              if(cont<=3)
              {
                  if(indices.contains("h")||indices.contains("H"))evaluacion=true;
                  else if(indices.contains("b")||indices.contains("B"))evaluacion=true;
                  else if(indices.contains("p")||indices.contains("P"))evaluacion=true;
              }
              insuficiencia=false;
              evaluacion=true;
         }
         return insuficiencia;
     }
     
     public void ActualizarNodo(Nodo actual)
     {
         this.posiciones=actual.posiciones;
         this.padre=actual.padre;
         this.color=actual.color;
         this.profundidad=actual.profundidad;
         this.tablero=GenerarTablero(this.posiciones);
         
     }
    
    public ArrayList DeterminarPosiblesJugadas(int color)
    {
        ArrayList<Nodo> jugadas=new ArrayList();
        int inicio=color;
        for (int i = 12+inicio; i > 0; i=i-2) {
            if(posiciones[i][0]!=-1)jugadas.addAll(Mover(posiciones[i],i)); 
        }
        jugadas.addAll(Mover(posiciones[14+color], 14+color));
        
        return jugadas;
    }
    
    boolean CasillaVacia(int posicion[])
    {
        boolean valido=true;
        int x=posicion[0],y=posicion[1];
        if((x<6)&&(x>=0)&&(y<6)&&(y>=0))
        {
            if(!tablero[x][y].equals("0"))valido=false;
            
        }else valido=false;
        
        return valido;        
    }
    
    int IndiceFicha(int posicion[])
    {
        int pos=-1,i=0;
        while(i<16)
        {
            if(posiciones[i][0]==posicion[0]&&posiciones[i][1]==posicion[1]){
                pos=i;
                break;
            }else i++;
        }
        return pos;        
    }
    
   public boolean FichaContraria(int posicion[],int color)
    {
      boolean contraria=false;
      int index=IndiceFicha(posicion);
      
      if(index>=0)
      {
          if((index%2)==(color+1)%2)contraria=true;
      }
      return contraria;
    }
   
   public void MoverCasillaVacia(ArrayList<Nodo> movimientos,int xi,int yi,int indiceFicha)
   {
       int cambioPosiciones[][]=new int [16][2];       
        System.arraycopy(this.posiciones, 0, cambioPosiciones, 0, 16);
        int colorActual=indiceFicha%2;
        cambioPosiciones[indiceFicha]=new int[]{xi,yi};
        Nodo actual=new Nodo(cambioPosiciones, new int[]{indiceFicha,xi,yi}, this, (colorActual+1)%2, this.profundidad+1);
        if(!actual.Jaque(colorActual))
        {
          movimientos.add(actual);  
        }
   }
   
  public void MoverCasillaContraria(ArrayList<Nodo> movimientos,int xi,int yi,int indiceFicha)
   {
       int cambioPosiciones[][]=new int [16][2];       
        System.arraycopy(this.posiciones, 0, cambioPosiciones, 0, 16);
        int colorActual=indiceFicha%2;
        cambioPosiciones[indiceFicha]=new int[]{xi,yi};
        int index=IndiceFicha(new int[]{xi,yi});
        if(index>=0)
        {
            cambioPosiciones[index]=new int[]{-1,-1};
            Nodo actual=new Nodo(cambioPosiciones, new int[]{indiceFicha,xi,yi}, this, (colorActual+1)%2, this.profundidad+1);
            if(!actual.Jaque(colorActual))
            {
              movimientos.add(actual);  
            }
        }
   }

    
    public ArrayList<Nodo> Mover(int posicion[],int indiceFicha)
    {
        String ficha=fichas[indiceFicha];
        ArrayList<Nodo> jugadas=new ArrayList();
        
        if(ficha.equals("p"))
        {
           jugadas.addAll(MovimientosPeonBlanco(posicion, indiceFicha));
        }
        else if(ficha.equals("P"))
        {
           jugadas.addAll(MovimientosPeonNegro(posicion, indiceFicha));
        }
        else if(ficha.equalsIgnoreCase("b")||ficha.equalsIgnoreCase("q"))
        {
            jugadas.addAll(MovimientosAlfilReina(posicion, indiceFicha));
        }
        else if(ficha.equalsIgnoreCase("h"))
        {           
           jugadas.addAll(MovimientosCaballo(posicion, indiceFicha));
           
        }else if(ficha.equalsIgnoreCase("k"))
        {
            jugadas.addAll(MovimientosRey(posicion, indiceFicha));
        }
        return jugadas;
    }

    public ArrayList<Nodo> MovimientosPeonBlanco(int posicion[],int indiceFicha)
    {
        int x=posicion[0],y=posicion[1];
        ArrayList<Nodo> movPeon=new ArrayList<Nodo>();
        if(x<5)
           {
               if(CasillaVacia(new int[]{x+1,y}))MoverCasillaVacia(movPeon, x+1, y, indiceFicha);
               for(int i=y-1;i<=y+1;i=i+2)
               {
                   if(FichaContraria(new int[]{x+1,i},0))MoverCasillaContraria(movPeon, x+1, i, indiceFicha);
               }
           }
        return movPeon;

    }

     public ArrayList<Nodo> MovimientosPeonNegro(int posicion[],int indiceFicha)
    {
        int x=posicion[0],y=posicion[1];
        ArrayList<Nodo> movPeon=new ArrayList<Nodo>();
           {
               if(CasillaVacia(new int[]{x-1,y}))MoverCasillaVacia(movPeon, x-1, y, indiceFicha);
               for(int i=y-1;i<=y+1;i=i+2)
               {
                   if(FichaContraria(new int[]{x-1,i},1))MoverCasillaContraria(movPeon, x-1, i, indiceFicha);
               }
               
           }
        return movPeon;
     }

      public ArrayList<Nodo> MovimientosAlfilReina(int posicion[],int indiceFicha)
      {
          ArrayList<Nodo> MovimientosAlfilReina=new ArrayList<Nodo>();
          String ficha=fichas[indiceFicha];
          MovimientosAlfilReina.addAll(MovimientoDiagonal(posicion[0], posicion[1], indiceFicha));
          if(ficha.equalsIgnoreCase("q"))MovimientosAlfilReina.addAll(MovimientoHorizontalVertical(posicion[0], posicion[1], indiceFicha));
          return MovimientosAlfilReina;
      }
      
      public ArrayList<Nodo> MovimientoHorizontalVertical(int x,int y,int indiceFicha)              
      {
          ArrayList<Nodo> movHorizontalVertical=new ArrayList<Nodo>();
          int colorActual=(indiceFicha%2),index;
          boolean movDer=true,movIzq=true,movArriba=true,movAbajo=true;
          int yi=y+1;
          while(movDer&&yi<6)
          {
              if(CasillaVacia(new int[]{x,yi}))MoverCasillaVacia(movHorizontalVertical, x, yi, indiceFicha);
              else{
                  if(FichaContraria(new int[]{x,yi},colorActual))MoverCasillaContraria(movHorizontalVertical, x, yi, indiceFicha);
                  movDer=false;
              } 
              yi++;
          }
          yi=y-1;
          while(movIzq&&yi>=0)
          {
              if(CasillaVacia(new int[]{x,yi}))MoverCasillaVacia(movHorizontalVertical, x, yi, indiceFicha);
              else{
                  if(FichaContraria(new int[]{x,yi},colorActual))MoverCasillaContraria(movHorizontalVertical, x, yi, indiceFicha);
                  movIzq=false;
              } 
              yi--;
          }
          int xi=x-1;
          while(movArriba&&xi>=0)
          {
              if(CasillaVacia(new int[]{xi,y}))MoverCasillaVacia(movHorizontalVertical, xi, y, indiceFicha);
              else{
                  if(FichaContraria(new int[]{xi,y},colorActual))MoverCasillaContraria(movHorizontalVertical, xi, yi, indiceFicha);
                  movArriba=false;
              } 
              xi--;
          }
          xi=x+1;
          while(movAbajo&&xi<6)
          {
              if(CasillaVacia(new int[]{xi,y}))MoverCasillaVacia(movHorizontalVertical, xi, y, indiceFicha);
              else{
                  if(FichaContraria(new int[]{xi,y},colorActual))MoverCasillaContraria(movHorizontalVertical, xi, y, indiceFicha);
                  movAbajo=false;
              } 
              xi++;
          }
          return movHorizontalVertical;
      }
      
      public ArrayList<Nodo> MovimientoDiagonal(int x,int y,int indiceFicha)              
      {
          ArrayList<Nodo> movDiagonal=new ArrayList<Nodo>();
          int colorActual=(indiceFicha%2),index;
          boolean diag1=true,diag2=true,diag3=true,diag4=true;
          int xi=x-1,yi=y-1;
          int min=Math.min(xi, yi);
          while(min>=0&&diag1)
          {
              if(CasillaVacia(new int[]{xi,yi}))MoverCasillaVacia(movDiagonal, xi, yi, indiceFicha);
              else {
                  if(FichaContraria(new int[]{xi,yi}, colorActual))MoverCasillaContraria(movDiagonal, xi, yi, indiceFicha);
                  diag1=false;
              }
              xi--;
              yi--;
              min=Math.min(xi, yi);    
          }
          xi=x-1;
          yi=y+1;
          min=Math.min(xi, yi);
          int max=Math.max(xi, yi);
          while(min>=0&&max<6&&diag2)
          {
              if(CasillaVacia(new int[]{xi,yi}))MoverCasillaVacia(movDiagonal, xi, yi, indiceFicha);
              else {
                  if(FichaContraria(new int[]{xi,yi}, colorActual))MoverCasillaContraria(movDiagonal, xi, yi, indiceFicha);
                  diag2=false;
              }
              xi--;
              yi++;
              min=Math.min(xi, yi);
              max=Math.max(xi, yi);
          }
          xi=x+1;
          yi=y-1;
          min=Math.min(xi, yi);
          max=Math.max(xi, yi);
          while(min>=0&&max<6&&diag3)
          {
              if(CasillaVacia(new int[]{xi,yi}))MoverCasillaVacia(movDiagonal, xi, yi, indiceFicha);
              else {
                  if(FichaContraria(new int[]{xi,yi}, colorActual))MoverCasillaContraria(movDiagonal, xi, yi, indiceFicha);
                  diag3=false;
              }
              xi++;
              yi--;
              min=Math.min(xi, yi);
              max=Math.max(xi, yi);
          }
          xi=x+1;
          yi=y+1;
          while(max<6&&diag4)
          {
              if(CasillaVacia(new int[]{xi,yi}))MoverCasillaVacia(movDiagonal, xi, yi, indiceFicha);
              else {
                  if(FichaContraria(new int[]{xi,yi}, colorActual))MoverCasillaContraria(movDiagonal, xi, yi, indiceFicha);
                  diag4=false;
              }
              xi++;
              yi++;
              max=Math.max(xi, yi);
          }
          return movDiagonal;
      }

      public ArrayList<Nodo> MovimientosCaballo(int posicion[],int indiceFicha)
      {
            int x=posicion[0],y=posicion[1];
            ArrayList<Nodo> movCaballo=new ArrayList<Nodo>();
            int colorActual=(indiceFicha%2);
           
            int incremento[]=new int[2];
           for (int i = 0; i < 8; i++) {
               incremento=incrementosCaballo[i];
                if(CasillaVacia(new int[]{x+incremento[0],y+incremento[1]}))MoverCasillaVacia(movCaballo, x+incremento[0], y+incremento[1], indiceFicha);
                else if(FichaContraria(new int[]{x+incremento[0],y+incremento[1]},colorActual))MoverCasillaContraria(movCaballo, x+incremento[0], y+incremento[1], indiceFicha);
            }
            return movCaballo;
      }

      public ArrayList<Nodo> MovimientosRey(int posicion[],int indiceFicha)
      {
            int x=posicion[0],y=posicion[1];
            ArrayList<Nodo> movRey=new ArrayList<Nodo>();
            int colorActual=(indiceFicha%2);
            int incremento[];
            for (int i = 0; i < 8; i++) {
               incremento=incrementos[i];
                if(CasillaVacia(new int[]{x+incremento[0],y+incremento[1]}))MoverCasillaVacia(movRey, x+incremento[0], y+incremento[1], indiceFicha);
                else if(FichaContraria(new int[]{x+incremento[0],y+incremento[1]},colorActual))MoverCasillaContraria(movRey, x+incremento[0], y+incremento[1], indiceFicha);
            }
            return movRey;
      }

       public ArrayList<int[]> GenerarPosiblesMovimientos(int posicion[])
      {
          ArrayList<int[]> jugadasPosibles=new ArrayList<int[]>();
          ArrayList<Nodo> movPosibles=new ArrayList<Nodo>();
          int indiceFicha=IndiceFicha(posicion);
          if(indiceFicha!=-1)
          {
              int opActual[];
              movPosibles=Mover(posicion, indiceFicha);
              for (int i = 0; i < movPosibles.size(); i++) {
                  opActual=movPosibles.get(i).operacionAplicada; 
                  jugadasPosibles.add(new int[]{opActual[1],opActual[2]});
              }
              return jugadasPosibles;
          }else return null;
      }
    
}
